Sky at Night 2007 June/SAN CD 6-2007 CD-ROM 25.iso/pc/Software/AstroGrav_Win/Java/jre1.6.0/lib/rt.jar/java/util/Random.class

Java Class File | 2006-11-29 | 3.7 KB | 161 lines

package java.util;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.ObjectStreamField;
import java.io.Serializable;
import java.io.StreamCorruptedException;
import java.util.concurrent.atomic.AtomicLong;
import sun.misc.Unsafe;

public class Random implements Serializable {
   static final long serialVersionUID = 3905348978240129619L;
   private final AtomicLong seed;
   private static final long multiplier = 25214903917L;
   private static final long addend = 11L;
   private static final long mask = 281474976710655L;
   private static volatile long seedUniquifier = 8682522807148012L;
   private double nextNextGaussian;
   private boolean haveNextNextGaussian;
   private static final ObjectStreamField[] serialPersistentFields;
   private static final Unsafe unsafe;
   private static final long seedOffset;

   public Random() {
      this(++seedUniquifier + System.nanoTime());
   }

   public Random(long var1) {
      this.haveNextNextGaussian = false;
      this.seed = new AtomicLong(0L);
      this.setSeed(var1);
   }

   public synchronized void setSeed(long var1) {
      var1 = (var1 ^ 25214903917L) & 281474976710655L;
      this.seed.set(var1);
      this.haveNextNextGaussian = false;
   }

   protected int next(int var1) {
      AtomicLong var6 = this.seed;

      long var2;
      long var4;
      do {
         var2 = var6.get();
         var4 = var2 * 25214903917L + 11L & 281474976710655L;
      } while(!var6.compareAndSet(var2, var4));

      return (int)(var4 >>> 48 - var1);
   }

   public void nextBytes(byte[] var1) {
      int var2 = 0;
      int var3 = var1.length;

      while(var2 < var3) {
         int var4 = this.nextInt();

         for(int var5 = Math.min(var3 - var2, 4); var5-- > 0; var4 >>= 8) {
            var1[var2++] = (byte)var4;
         }
      }

   }

   public int nextInt() {
      return this.next(32);
   }

   public int nextInt(int var1) {
      if (var1 <= 0) {
         throw new IllegalArgumentException("n must be positive");
      } else if ((var1 & -var1) == var1) {
         return (int)((long)var1 * (long)this.next(31) >> 31);
      } else {
         int var2;
         int var3;
         do {
            var2 = this.next(31);
            var3 = var2 % var1;
         } while(var2 - var3 + (var1 - 1) < 0);

         return var3;
      }
   }

   public long nextLong() {
      return ((long)this.next(32) << 32) + (long)this.next(32);
   }

   public boolean nextBoolean() {
      return this.next(1) != 0;
   }

   public float nextFloat() {
      return (float)this.next(24) / 1.6777216E7F;
   }

   public double nextDouble() {
      return (double)(((long)this.next(26) << 27) + (long)this.next(27)) / (double)9.007199E15F;
   }

   public synchronized double nextGaussian() {
      if (this.haveNextNextGaussian) {
         this.haveNextNextGaussian = false;
         return this.nextNextGaussian;
      } else {
         double var1;
         double var3;
         double var5;
         do {
            var1 = (double)2.0F * this.nextDouble() - (double)1.0F;
            var3 = (double)2.0F * this.nextDouble() - (double)1.0F;
            var5 = var1 * var1 + var3 * var3;
         } while(var5 >= (double)1.0F || var5 == (double)0.0F);

         double var7 = StrictMath.sqrt((double)-2.0F * StrictMath.log(var5) / var5);
         this.nextNextGaussian = var3 * var7;
         this.haveNextNextGaussian = true;
         return var1 * var7;
      }
   }

   private void readObject(ObjectInputStream var1) throws IOException, ClassNotFoundException {
      ObjectInputStream.GetField var2 = var1.readFields();
      long var3 = var2.get("seed", -1L);
      if (var3 < 0L) {
         throw new StreamCorruptedException("Random: invalid seed");
      } else {
         this.resetSeed(var3);
         this.nextNextGaussian = var2.get("nextNextGaussian", (double)0.0F);
         this.haveNextNextGaussian = var2.get("haveNextNextGaussian", false);
      }
   }

   private synchronized void writeObject(ObjectOutputStream var1) throws IOException {
      ObjectOutputStream.PutField var2 = var1.putFields();
      var2.put("seed", this.seed.get());
      var2.put("nextNextGaussian", this.nextNextGaussian);
      var2.put("haveNextNextGaussian", this.haveNextNextGaussian);
      var1.writeFields();
   }

   private void resetSeed(long var1) {
      unsafe.putObjectVolatile(this, seedOffset, new AtomicLong(var1));
   }

   static {
      serialPersistentFields = new ObjectStreamField[]{new ObjectStreamField("seed", Long.TYPE), new ObjectStreamField("nextNextGaussian", Double.TYPE), new ObjectStreamField("haveNextNextGaussian", Boolean.TYPE)};
      unsafe = Unsafe.getUnsafe();

      try {
         seedOffset = unsafe.objectFieldOffset(Random.class.getDeclaredField("seed"));
      } catch (Exception var1) {
         throw new Error(var1);
      }
   }
}